{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 环境配置\n",
    "第一步：设置python版本为3.9.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture captured_output\n",
    "!/home/ma-user/anaconda3/bin/conda create -n python-3.9.0 python=3.9.0 -y --override-channels --channel https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main\n",
    "!/home/ma-user/anaconda3/envs/python-3.9.0/bin/pip install ipykernel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "import os\n",
    "\n",
    "data = {\n",
    "   \"display_name\": \"python-3.9.0\",\n",
    "   \"env\": {\n",
    "      \"PATH\": \"/home/ma-user/anaconda3/envs/python-3.9.0/bin:/home/ma-user/anaconda3/envs/python-3.7.10/bin:/modelarts/authoring/notebook-conda/bin:/opt/conda/bin:/usr/local/nvidia/bin:/usr/local/cuda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/home/ma-user/modelarts/ma-cli/bin:/home/ma-user/modelarts/ma-cli/bin\"\n",
    "   },\n",
    "   \"language\": \"python\",\n",
    "   \"argv\": [\n",
    "      \"/home/ma-user/anaconda3/envs/python-3.9.0/bin/python\",\n",
    "      \"-m\",\n",
    "      \"ipykernel\",\n",
    "      \"-f\",\n",
    "      \"{connection_file}\"\n",
    "   ]\n",
    "}\n",
    "\n",
    "if not os.path.exists(\"/home/ma-user/anaconda3/share/jupyter/kernels/python-3.9.0/\"):\n",
    "    os.mkdir(\"/home/ma-user/anaconda3/share/jupyter/kernels/python-3.9.0/\")\n",
    "\n",
    "with open('/home/ma-user/anaconda3/share/jupyter/kernels/python-3.9.0/kernel.json', 'w') as f:\n",
    "    json.dump(data, f, indent=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "注：以上代码运行完成后，需要重新设置kernel为python-3.9.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "第二步：安装MindSpore框架"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture captured_output\n",
    "!pip install https://ms-release.obs.cn-north-4.myhuaweicloud.com/2.2.14/MindSpore/unified/x86_64/mindspore-2.2.14-cp39-cp39-linux_x86_64.whl --trusted-host ms-release.obs.cn-north-4.myhuaweicloud.com -i https://pypi.tuna.tsinghua.edu.cn/simple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%capture captured_output\n",
    "!pip install download\n",
    "!pip install matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mindspore import nn\n",
    "import mindspore.ops as ops\n",
    "from mindspore import Tensor\n",
    "\n",
    "class GroupConv(nn.Cell):\n",
    "    def __init__(self, in_channels, out_channels, kernel_size,\n",
    "                 stride, pad_mode=\"pad\", pad=0, groups=1, has_bias=False):\n",
    "        super(GroupConv, self).__init__()\n",
    "        self.groups = groups\n",
    "        self.convs = nn.CellList()\n",
    "        for _ in range(groups):\n",
    "            self.convs.append(nn.Conv2d(in_channels // groups, out_channels // groups,\n",
    "                                        kernel_size=kernel_size, stride=stride, has_bias=has_bias,\n",
    "                                        padding=pad, pad_mode=pad_mode, group=1, weight_init='xavier_uniform'))\n",
    "\n",
    "    def construct(self, x):\n",
    "        features = ops.split(x, split_size_or_sections=int(len(x[0]) // self.groups), axis=1)\n",
    "        outputs = ()\n",
    "        for i in range(self.groups):\n",
    "            outputs = outputs + (self.convs[i](features[i].astype(\"float32\")),)\n",
    "        out = ops.cat(outputs, axis=1)\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ShuffleV1Block(nn.Cell):\n",
    "    def __init__(self, inp, oup, group, first_group, mid_channels, ksize, stride):\n",
    "        super(ShuffleV1Block, self).__init__()\n",
    "        self.stride = stride\n",
    "        pad = ksize // 2\n",
    "        self.group = group\n",
    "        if stride == 2:\n",
    "            outputs = oup - inp\n",
    "        else:\n",
    "            outputs = oup\n",
    "        self.relu = nn.ReLU()\n",
    "        branch_main_1 = [\n",
    "            GroupConv(in_channels=inp, out_channels=mid_channels,\n",
    "                      kernel_size=1, stride=1, pad_mode=\"pad\", pad=0,\n",
    "                      groups=1 if first_group else group),\n",
    "            nn.BatchNorm2d(mid_channels),\n",
    "            nn.ReLU(),\n",
    "        ]\n",
    "        branch_main_2 = [\n",
    "            nn.Conv2d(mid_channels, mid_channels, kernel_size=ksize, stride=stride,\n",
    "                      pad_mode='pad', padding=pad, group=mid_channels,\n",
    "                      weight_init='xavier_uniform', has_bias=False),\n",
    "            nn.BatchNorm2d(mid_channels),\n",
    "            GroupConv(in_channels=mid_channels, out_channels=outputs,\n",
    "                      kernel_size=1, stride=1, pad_mode=\"pad\", pad=0,\n",
    "                      groups=group),\n",
    "            nn.BatchNorm2d(outputs),\n",
    "        ]\n",
    "        self.branch_main_1 = nn.SequentialCell(branch_main_1)\n",
    "        self.branch_main_2 = nn.SequentialCell(branch_main_2)\n",
    "        if stride == 2:\n",
    "            self.branch_proj = nn.AvgPool2d(kernel_size=3, stride=2, pad_mode='same')\n",
    "\n",
    "    def construct(self, old_x):\n",
    "        left = old_x\n",
    "        right = old_x\n",
    "        out = old_x\n",
    "        right = self.branch_main_1(right)\n",
    "        if self.group > 1:\n",
    "            right = self.channel_shuffle(right)\n",
    "        right = self.branch_main_2(right)\n",
    "        if self.stride == 1:\n",
    "            out = self.relu(left + right)\n",
    "        elif self.stride == 2:\n",
    "            left = self.branch_proj(left)\n",
    "            out = ops.cat((left, right), 1)\n",
    "            out = self.relu(out)\n",
    "        return out\n",
    "\n",
    "    def channel_shuffle(self, x):\n",
    "        batchsize, num_channels, height, width = ops.shape(x)\n",
    "        group_channels = num_channels // self.group\n",
    "        x = ops.reshape(x, (batchsize, group_channels, self.group, height, width))\n",
    "        x = ops.transpose(x, (0, 2, 1, 3, 4))\n",
    "        x = ops.reshape(x, (batchsize, num_channels, height, width))\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ShuffleNetV1(nn.Cell):\n",
    "    def __init__(self, n_class=1000, model_size='2.0x', group=3):\n",
    "        super(ShuffleNetV1, self).__init__()\n",
    "        print('model size is ', model_size)\n",
    "        self.stage_repeats = [4, 8, 4]\n",
    "        self.model_size = model_size\n",
    "        if group == 3:\n",
    "            if model_size == '0.5x':\n",
    "                self.stage_out_channels = [-1, 12, 120, 240, 480]\n",
    "            elif model_size == '1.0x':\n",
    "                self.stage_out_channels = [-1, 24, 240, 480, 960]\n",
    "            elif model_size == '1.5x':\n",
    "                self.stage_out_channels = [-1, 24, 360, 720, 1440]\n",
    "            elif model_size == '2.0x':\n",
    "                self.stage_out_channels = [-1, 48, 480, 960, 1920]\n",
    "            else:\n",
    "                raise NotImplementedError\n",
    "        elif group == 8:\n",
    "            if model_size == '0.5x':\n",
    "                self.stage_out_channels = [-1, 16, 192, 384, 768]\n",
    "            elif model_size == '1.0x':\n",
    "                self.stage_out_channels = [-1, 24, 384, 768, 1536]\n",
    "            elif model_size == '1.5x':\n",
    "                self.stage_out_channels = [-1, 24, 576, 1152, 2304]\n",
    "            elif model_size == '2.0x':\n",
    "                self.stage_out_channels = [-1, 48, 768, 1536, 3072]\n",
    "            else:\n",
    "                raise NotImplementedError\n",
    "        input_channel = self.stage_out_channels[1]\n",
    "        self.first_conv = nn.SequentialCell(\n",
    "            nn.Conv2d(3, input_channel, 3, 2, 'pad', 1, weight_init='xavier_uniform', has_bias=False),\n",
    "            nn.BatchNorm2d(input_channel),\n",
    "            nn.ReLU(),\n",
    "        )\n",
    "        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, pad_mode='same')\n",
    "        features = []\n",
    "        for idxstage in range(len(self.stage_repeats)):\n",
    "            numrepeat = self.stage_repeats[idxstage]\n",
    "            output_channel = self.stage_out_channels[idxstage + 2]\n",
    "            for i in range(numrepeat):\n",
    "                stride = 2 if i == 0 else 1\n",
    "                first_group = idxstage == 0 and i == 0\n",
    "                features.append(ShuffleV1Block(input_channel, output_channel,\n",
    "                                               group=group, first_group=first_group,\n",
    "                                               mid_channels=output_channel // 4, ksize=3, stride=stride))\n",
    "                input_channel = output_channel\n",
    "        self.features = nn.SequentialCell(features)\n",
    "        self.globalpool = nn.AvgPool2d(7)\n",
    "        self.classifier = nn.Dense(self.stage_out_channels[-1], n_class)\n",
    "\n",
    "    def construct(self, x):\n",
    "        x = self.first_conv(x)\n",
    "        x = self.maxpool(x)\n",
    "        x = self.features(x)\n",
    "        x = self.globalpool(x)\n",
    "        x = ops.reshape(x, (-1, self.stage_out_channels[-1]))\n",
    "        x = self.classifier(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 模型训练和评估\n",
    "\n",
    "采用CIFAR-10数据集对ShuffleNet进行预训练。\n",
    "\n",
    "### 训练集准备与加载\n",
    "\n",
    "采用CIFAR-10数据集对ShuffleNet进行预训练。CIFAR-10共有60000张32*32的彩色图像，均匀地分为10个类别，其中50000张图片作为训练集，10000图片作为测试集。如下示例使用`mindspore.dataset.Cifar10Dataset`接口下载并加载CIFAR-10的训练集。目前仅支持二进制版本（CIFAR-10 binary version）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from download import download\n",
    "\n",
    "url = \"https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/datasets/cifar-10-binary.tar.gz\"\n",
    "\n",
    "download(url, \"./dataset\", kind=\"tar.gz\", replace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import mindspore as ms\n",
    "from mindspore.dataset import Cifar10Dataset\n",
    "from mindspore.dataset import vision, transforms\n",
    "\n",
    "def get_dataset(train_dataset_path, batch_size, usage):\n",
    "    image_trans = []\n",
    "    if usage == \"train\":\n",
    "        image_trans = [\n",
    "            vision.RandomCrop((32, 32), (4, 4, 4, 4)),\n",
    "            vision.RandomHorizontalFlip(prob=0.5),\n",
    "            vision.Resize((224, 224)),\n",
    "            vision.Rescale(1.0 / 255.0, 0.0),\n",
    "            vision.Normalize([0.4914, 0.4822, 0.4465], [0.2023, 0.1994, 0.2010]),\n",
    "            vision.HWC2CHW()\n",
    "        ]\n",
    "    elif usage == \"test\":\n",
    "        image_trans = [\n",
    "            vision.Resize((224, 224)),\n",
    "            vision.Rescale(1.0 / 255.0, 0.0),\n",
    "            vision.Normalize([0.4914, 0.4822, 0.4465], [0.2023, 0.1994, 0.2010]),\n",
    "            vision.HWC2CHW()\n",
    "        ]\n",
    "    label_trans = transforms.TypeCast(ms.int32)\n",
    "    dataset = Cifar10Dataset(train_dataset_path, usage=usage, shuffle=True)\n",
    "    dataset = dataset.map(image_trans, 'image')\n",
    "    dataset = dataset.map(label_trans, 'label')\n",
    "    dataset = dataset.batch(batch_size, drop_remainder=True)\n",
    "    return dataset\n",
    "\n",
    "dataset = get_dataset(\"./dataset/cifar-10-batches-bin\", 128, \"train\")\n",
    "batches_per_epoch = dataset.get_dataset_size()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 模型训练\n",
    "\n",
    "本节用随机初始化的参数做预训练。首先调用`ShuffleNetV1`定义网络，参数量选择`\"2.0x\"`，并定义损失函数为交叉熵损失，学习率经过4轮的`warmup`后采用余弦退火，优化器采用`Momentum`。最后用`train.model`中的`Model`接口将模型、损失函数、优化器封装在`model`中，并用`model.train()`对网络进行训练。将`ModelCheckpoint`、`CheckpointConfig`、`TimeMonitor`和`LossMonitor`传入回调函数中，将会打印训练的轮数、损失和时间，并将ckpt文件保存在当前目录下。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model size is  2.0x\n",
      "\n",
      "============== Starting Training ==============\n",
      "\n",
      "epoch: 1 step: 391, loss is 1.8377745151519775\n",
      "\n",
      "epoch: 2 step: 391, loss is 1.825901403427124\n",
      "\n",
      "epoch: 3 step: 391, loss is 1.8933873176574707\n",
      "\n",
      "...                                        ...\n",
      "\n",
      "epoch: 248 step: 391, loss is 0.6060634851455688\n",
      "\n",
      "epoch: 249 step: 391, loss is 0.604820728302002\n",
      "\n",
      "epoch: 250 step: 391, loss is 0.6010043621063232\n",
      "\n",
      "Train epoch time: 305032.881 ms, per step time: 780.135 ms\n",
      "\n",
      "total time:21h 4m 27s\n",
      "\n",
      "============== Train Success ==============\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "import mindspore\n",
    "import numpy as np\n",
    "from mindspore import Tensor, nn\n",
    "from mindspore.train import ModelCheckpoint, CheckpointConfig, TimeMonitor, LossMonitor, Model, Top1CategoricalAccuracy, Top5CategoricalAccuracy\n",
    "\n",
    "def train():\n",
    "    mindspore.set_context(mode=mindspore.PYNATIVE_MODE, device_target=\"GPU\")\n",
    "    net = ShuffleNetV1(model_size=\"2.0x\", n_class=10)\n",
    "    loss = nn.CrossEntropyLoss(weight=None, reduction='mean', label_smoothing=0.1)\n",
    "    min_lr = 0.0005\n",
    "    base_lr = 0.05\n",
    "    lr_scheduler = mindspore.nn.cosine_decay_lr(min_lr,\n",
    "                                                base_lr,\n",
    "                                                batches_per_epoch*250,\n",
    "                                                batches_per_epoch,\n",
    "                                                decay_epoch=250)\n",
    "    lr = Tensor(lr_scheduler[-1])\n",
    "    optimizer = nn.Momentum(params=net.trainable_params(), learning_rate=lr, momentum=0.9, weight_decay=0.00004, loss_scale=1024)\n",
    "    loss_scale_manager = ms.amp.FixedLossScaleManager(1024, drop_overflow_update=False)\n",
    "    model = Model(net, loss_fn=loss, optimizer=optimizer, amp_level=\"O3\", loss_scale_manager=loss_scale_manager)\n",
    "    callback = [TimeMonitor(), LossMonitor()]\n",
    "    save_ckpt_path = \"./\"\n",
    "    config_ckpt = CheckpointConfig(save_checkpoint_steps=batches_per_epoch, keep_checkpoint_max=5)\n",
    "    ckpt_callback = ModelCheckpoint(\"shufflenetv1\", directory=save_ckpt_path, config=config_ckpt)\n",
    "    callback += [ckpt_callback]\n",
    "\n",
    "    print(\"============== Starting Training ==============\")\n",
    "    start_time = time.time()\n",
    "    model.train(250, dataset, callbacks=callback)\n",
    "    use_time = time.time() - start_time\n",
    "    hour = str(int(use_time // 60 // 60))\n",
    "    minute = str(int(use_time // 60 % 60))\n",
    "    second = str(int(use_time % 60))\n",
    "    print(\"total time:\" + hour + \"h \" + minute + \"m \" + second + \"s\")\n",
    "    print(\"============== Train Success ==============\")\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    train()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "训练好的模型保存在当前目录的`shufflenetv1-250_391.ckpt`中，用作评估。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 模型评估\n",
    "\n",
    "在CIFAR-10的测试集上对模型进行评估。\n",
    "\n",
    "设置好评估模型的路径后加载数据集，并设置Top 1, Top 5的评估标准，最后用`model.eval()`接口对模型进行评估。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model size is  2.0x\n",
      "\n",
      "result:{'Loss': 1.0217913215673422, 'Top_1_Acc': 0.8152, 'Top_5_Acc': 0.975}, ckpt:'./shufflenetv1-250_391.ckpt', time: 0h 0m 21s\n"
     ]
    }
   ],
   "source": [
    "from mindspore import load_checkpoint, load_param_into_net\n",
    "\n",
    "def test():\n",
    "    mindspore.set_context(mode=mindspore.GRAPH_MODE, device_target=\"GPU\")\n",
    "    dataset = get_dataset(\"./dataset/cifar-10-batches-bin\", 128, \"test\")\n",
    "    net = ShuffleNetV1(model_size=\"2.0x\", n_class=10)\n",
    "    param_dict = load_checkpoint(\"shufflenetv1-250_391.ckpt\")\n",
    "    load_param_into_net(net, param_dict)\n",
    "    net.set_train(False)\n",
    "    loss = nn.CrossEntropyLoss(weight=None, reduction='mean', label_smoothing=0.1)\n",
    "    eval_metrics = {'Loss': nn.Loss(), 'Top_1_Acc': Top1CategoricalAccuracy(),\n",
    "                    'Top_5_Acc': Top5CategoricalAccuracy()}\n",
    "    model = Model(net, loss_fn=loss, metrics=eval_metrics)\n",
    "    start_time = time.time()\n",
    "    res = model.eval(dataset, dataset_sink_mode=False)\n",
    "    use_time = time.time() - start_time\n",
    "    hour = str(int(use_time // 60 // 60))\n",
    "    minute = str(int(use_time // 60 % 60))\n",
    "    second = str(int(use_time % 60))\n",
    "    log = \"result:\" + str(res) + \", ckpt:'\" + \"./shufflenetv1-250_391.ckpt\" \\\n",
    "        + \"', time: \" + hour + \"h \" + minute + \"m \" + second + \"s\"\n",
    "    print(log)\n",
    "    filename = './eval_log.txt'\n",
    "    with open(filename, 'a') as file_object:\n",
    "        file_object.write(log + '\\n')\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    test()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 模型预测\n",
    "\n",
    "在CIFAR-10的测试集上对模型进行预测，并将预测结果可视化。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model size is  2.0x\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x360 with 16 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import mindspore\n",
    "import matplotlib.pyplot as plt\n",
    "import mindspore.dataset as ds\n",
    "\n",
    "net = ShuffleNetV1(model_size=\"2.0x\", n_class=10)\n",
    "show_lst = []\n",
    "param_dict = load_checkpoint(\"shufflenetv1-250_391.ckpt\")\n",
    "load_param_into_net(net, param_dict)\n",
    "model = Model(net)\n",
    "dataset_predict = ds.Cifar10Dataset(dataset_dir=\"./dataset/cifar-10-batches-bin\", shuffle=False, usage=\"train\")\n",
    "dataset_show = ds.Cifar10Dataset(dataset_dir=\"./dataset/cifar-10-batches-bin\", shuffle=False, usage=\"train\")\n",
    "dataset_show = dataset_show.batch(16)\n",
    "show_images_lst = next(dataset_show.create_dict_iterator())[\"image\"].asnumpy()\n",
    "image_trans = [\n",
    "    vision.RandomCrop((32, 32), (4, 4, 4, 4)),\n",
    "    vision.RandomHorizontalFlip(prob=0.5),\n",
    "    vision.Resize((224, 224)),\n",
    "    vision.Rescale(1.0 / 255.0, 0.0),\n",
    "    vision.Normalize([0.4914, 0.4822, 0.4465], [0.2023, 0.1994, 0.2010]),\n",
    "    vision.HWC2CHW()\n",
    "        ]\n",
    "dataset_predict = dataset_predict.map(image_trans, 'image')\n",
    "dataset_predict = dataset_predict.batch(16)\n",
    "class_dict = {0:\"airplane\", 1:\"automobile\", 2:\"bird\", 3:\"cat\", 4:\"deer\", 5:\"dog\", 6:\"frog\", 7:\"horse\", 8:\"ship\", 9:\"truck\"}\n",
    "# 推理效果展示(上方为预测的结果，下方为推理效果图片)\n",
    "plt.figure(figsize=(16, 5))\n",
    "predict_data = next(dataset_predict.create_dict_iterator())\n",
    "output = model.predict(ms.Tensor(predict_data['image']))\n",
    "pred = np.argmax(output.asnumpy(), axis=1)\n",
    "index = 0\n",
    "for image in show_images_lst:\n",
    "    plt.subplot(2, 8, index+1)\n",
    "    plt.title('{}'.format(class_dict[pred[index]]))\n",
    "    index += 1\n",
    "    plt.imshow(image)\n",
    "    plt.axis(\"off\")\n",
    "plt.show()\n"
   ]
  }
 ],
 "metadata": {
  "AIGalleryInfo": "",
  "flavorInfo": {
   "architecture": "X86_64",
   "category": "GPU"
  },
  "imageInfo": {
   "id": "e1a07296-22a8-4f05-8bc8-e936c8e54202",
   "name": "mindspore1.7.0-cuda10.1-py3.7-ubuntu18.04"
  },
  "kernelspec": {
   "display_name": "python-3.9.0",
   "language": "python",
   "name": "python-3.9.0"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.0"
  },
  "vscode": {
   "interpreter": {
    "hash": "5d834606fceea8447e1f2d2b8feecce2028f1eecd4b0eabaa8daf1aeed30752e"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
